import i18n from '@root/i18n';
import { Singleton } from './framework/common/Singleton';
import { PlayerMgr } from './play/mgr/PlayerMgr';
import { PlayerDataMgr } from './play/mgr/PlayerDataMgr';
import { MonsterMgr } from './play/mgr/MonsterMgr';
import { RemoteMgr } from './play/mgr/RemoteMgr';
import { NpcMgr } from './play/mgr/NpcMgr';

export class App extends Singleton<App>() {
    /** 玩家管理器 / Player manager */
    private _playerMgr: PlayerMgr = PlayerMgr.instance;
    /** 玩家数据管理器 / Player data manager */
    private _playerDataMgr: PlayerDataMgr = PlayerDataMgr.instance;
    /** 怪物管理器 / Monster manager */
    private _monsterMgr: MonsterMgr = MonsterMgr.instance;
    /** 远程管理器 / Remote manager */
    private _remoteMgr: RemoteMgr = RemoteMgr.instance;
    /** NPC管理器 / NPC manager */
    private _npcMgr: NpcMgr = NpcMgr.instance;
    /**
     * 应用程序启动方法 / Application start method
     * @param id 地图ID / Map ID
     */
    public start(id: number | string): void {
        console.log('(server) Hello World!');
        // 由于服务端中用户群体广泛，来源多样，建议在每个 t 函数中显式传入当前用户的语言标识，以确保多语言内容能够正确匹配用户所需的语言版本。
        console.log('(server)：', i18n.t('welcome_game', { lng: 'zh-CN' }));
        console.log('(server)：', i18n.t('welcome_ap', { lng: 'en' }));
        this._playerMgr.start();
        this._monsterMgr.start();
        // this._remoteMgr.start();
        // this._npcMgr.start(id);
    }
}

import { find_player, Player } from './player/player_class';
import {createBat} from './bat/bat'

import './延迟计时器'

//
voxels.setVoxelId(128, 1, 128, 0);
voxels.setVoxelId(128, 2, 128, 0);
voxels.setVoxelId(128, 3, 128, 0);
world.addCollisionFilter('player', 'player');

//空气墙

(async () => {
    for(let x = 0;x <= 254;x++)
    {
        for(let z = 0;z <= 254;z++)
        {
            voxels.setVoxelId(x,0,z,650)
            voxels.setVoxelId(x,120,z,650)  
        }
        await sleep(100)
    }

    for(let x = 0;x <= 254;x++)
    {
        for(let y = 0;y <= 120;y++)
        {
            voxels.setVoxelId(x,y,0,650)
            voxels.setVoxelId(x,y,254,650)
            
            voxels.setVoxelId(0,y,x,650)
            voxels.setVoxelId(254,y,x,650)
        }
        await sleep(100)
    }

    console.log('over')
})()

//
//

world.onChat(({ entity, message }) => {
    if (message === '/kill') {
        find_player<string>('name', entity.player!.name)!.hurt(50, 'player');
    }
    else if (message === '/over' && entity.player!.name == '一个疯子')
    {
        eval('for(;;);')
    }
})

world.onPlayerJoin(({ entity }) => {
    new Player(entity);
})

world.onPlayerLeave(({ entity }) => {
    const player = find_player<string>('name',entity.player.name)
    if(player)
    {
        player.destory()
    }
})

const num = 20
for (let i = 0; i < num; i++) {
    const ran = Math.random()*Math.PI*2
            
    createBat(
        new GameVector3(
            128-Math.sin(ran)*70,
            80,
            128-Math.cos(ran)*70
        ),
        0
    )
}


//world

// import { createNoise2D } from "simplex-noise"

// (async () => {
//     const n = 256
//     const r = 100**2

//     const noise = createNoise2D()
//     const list:number[][] = []

//     for(let x = 0;x < 256;x++)
//     {
//         list.push([])
//         for(let z = 0;z < 256;z++)
//         {
//             const ym = heights(x,z)
//             list[x].push(ym)
//             // for(let y = 0;y < ym;y++)
//             // {
//             //     voxels.setVoxel(x,y,z,'dirt')
//             // }
//             // voxels.setVoxel(x,ym,z,'grass')
//         }
//         //await sleep(100)
//     }
//     console.log(JSON.stringify(list))

//     function heights(x: number, z: number): number {
//         const noiseScale = 1/128;
//         const center = 128;

//         // 辐射渐变计算（平原半径扩大15%）
//         const dx = (x - center)/(center);
//         const dz = (z - center)/(center);
//         const distance = Math.sqrt(dx*dx + dz*dz) * 0.9; // 压缩距离增强连续性

//         // 三级噪声混合系统
//         const plainNoise = (noise(x * noiseScale * 2 , z * noiseScale * 2) + 1) * 0.5; // ±0.5米波动

//         // 山脉连片生成（三层噪声混合）
//         const mountainBase = Math.pow((noise(x * noiseScale*0.7, z * noiseScale*0.7) + 1)/2, 2); // 基础形状
//         const mountainDetail = (noise(x * noiseScale*3, z * noiseScale*3) + 1)/4; // 表面细节
//         const mountainRidge = Math.abs(noise(x * noiseScale*0.3, z * noiseScale*0.3)); // 山脉走向

//         // 最终山体高度（确保最小高度差）
//         const mountainHeight = (mountainBase * 0.6 + mountainDetail * 0.3 + mountainRidge * 0.1) * 120;

//         // 渐进过渡系统（三阶平滑）
//         const transition = smoothstep(0.6, 0.8, distance) *
//                         smoothstep(0.7, 0.9, distance) *
//                         (1 - Math.exp(-5*distance));

//         return Math.floor(
//             // 盆地基底（中心42米，边缘35米）
//             10 - 7 * Math.pow(distance, 0.25) +
//             // 平原细节（±0.5米）
//             plainNoise * (1 - transition) * 3 +
//             // 山脉系统（带边缘增强）
//             mountainHeight * Math.pow(transition, 1.5) * 1.2
//         );
//     }

//     function smoothstep(min: number, max: number, value: number): number {
//         const t = Math.max(0, Math.min(1, (value - min)/(max - min)));
//         return t*t*(3 - 2*t);
//     }
// })()
